44c267398a21fa8fa978438bb32b450e7257e2d4,src/dorkbox/util/tweenengine/BaseTween.java,BaseTween,update,#number#,545

Before Change


        // will trickle-down.
        // We update ALL following objects. If a tween is before start (reverse) or past end (forwards), this it will "snap" to the
        // start/end endpoints
        doUpdate(direction, originalDelta);
    }

    protected

After Change


                }

                currentTime = newTime;
                doUpdate(FORWARDS, originalDelta);
                return;
            }

            // we have gone past our iteration point

            // adjust the delta so that it is shifted based on the length of (previous) iteration
            delta = newTime - duration;

            // set our currentTime for the callbacks to be accurate and updates to lock to start/end values
            currentTime = duration;

            // flip our state
            insideDelay = true;

            // make sure that we manage our children BEFORE we do anything else!
            // we use originalDelta here because we have to trickle-down the logic to all children. If we use delta, the incorrect value
            // will trickle-down
            doUpdate(FORWARDS, originalDelta);

            callCallbacks(TweenCallback.Events.END);


            ////////////////////////////////////////////
            ////////////////////////////////////////////
            // 1) we are done running completely
            // 2) we flip to auto-reverse repeat mode
            // 3) we are in linear repeat mode
            if (repeatCount <= 0) {
                // {FORWARDS}{FINISHED}
                // no repeats left, so we're done

                // TRANSITION to finished
                // really are done (so no more event notification loops)
                isFinished = true;
                isInAutoReverse = false;

                // we're done going forwards
                canTriggerBeginEvent = true;
                callCallbacks(TweenCallback.Events.COMPLETE);

                // now adjust the time so PARENT reversing/etc works
                currentTime = duration + delta;
            }
            else if (canAutoReverse) {
                // {FORWARDS}{AUTO_REVERSE}
                repeatCount--;

                // we're done going forwards
                canTriggerBeginEvent = true;
                isInAutoReverse = !isInAutoReverse; // if we are NOT in autoReverse, then "isInAutoReverse" is true if we reverse
                this.direction = false; // make sure any checks after this returns accurately reflect the correct direction

                callCallbacks(TweenCallback.Events.COMPLETE);

                // setup delays, if there are any. have to adjust for any "extra" time wrapped beyond duration
                currentTime = -delta;
                addRepeatDelay(repeatDelay);

                // has to be after addRepeatDelay()
                isFinished = false;
            } else {
                // {FORWARDS}{LINEAR}
                repeatCount--;

                //  have to adjust for any "extra" time wrapped beyond duration
                currentTime = delta + duration;
                forceRestart(-duration);
                addRepeatDelay(-repeatDelay);

                // have to re-put back settings, has to be after addRepeatDelay()
                insideDelay = true;
                isFinished = false;
                isInAutoReverse = false;
            }

            // </editor-fold>
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        else {
            // {REVERSE}
            // <editor-fold>

            // FORWARDS and REVERSE are different conditions
            boolean insideLow = newTime > 0;
            boolean insideHigh = newTime <= duration;
            // check for newTime <=duration, because we can have > duration time when in a repeat-delay

            if (isFinished) {
                if (insideLow && insideHigh) {
                    // we reversed somewhere, and now should be back running again.
                    isFinished = false;
                    insideDelay = false;
                    triggerStartEvent = true;
                }
                else {
                    // the time that a tween/timeline runs over when it is done running, so reversing still correctly tracks delays, etc
                    currentTime = newTime;

                    doUpdate(REVERSE, originalDelta);
                    return;
                }
            }
            else if (insideDelay) {
                if (insideLow) {
                    // still inside our repeat delay, since repeat delay is always positive (going reverse)

                    // adjust our time
                    currentTime = newTime;

                    // return because we have to make sure that our children are updated (to preserve reversing delays/behavior)
                    doUpdate(REVERSE, originalDelta);
                    return;
                } else {
                    // have to specify that the children should restart
                    delta = newTime;
                    newTime = duration + delta; // delta is negative here

                    // have to offset currentTime, so currentTime + (repeatDelay + (0)) ==> duration
                    currentTime = duration - repeatDelay + originalDelta;
                    forceRestart(0);

                    insideLow = true;
                    insideHigh = true;
                    canTriggerBeginEvent = true;
                    // continue to running normally
                }
            }
            // we are running normally, can get here from other states

            if (insideLow) {
                if (insideHigh && triggerStartEvent) {
                    currentTime = duration; // this is reset below...
                    triggerStartEvent = false;
                    if (canTriggerBeginEvent) {
                        canTriggerBeginEvent = false;
                        callCallbacks(TweenCallback.Events.BACK_BEGIN);
                    }

                    callCallbacks(TweenCallback.Events.BACK_START);
                }

                currentTime = newTime;

                doUpdate(REVERSE, originalDelta);
                return;
            }